// 购物车模块

import { getNewCartGoods, mergeLocalCart, findCartList, insetCart, deleteCart, updateCart, checkAllCart } from '@/api/cart'
export default {
  namespaced: true,
  state () {
    return {
      list: []
    }
  },
  mutations: {
    // 加入购物车指令
    insetCart (state, payload) {
      // 约定加入购物车后字段必须跟后端的保持一致 payload对象字段
      // 它们是：id skuId name attrsText picture price nowPrice selected stock count isEffective
      // 插入数据规则
      // 先找是否有相同商品
      // 如果有相同的商品,查询他们的数量,累加导payload上,在保存最新位置,原来的商品需要伤处
      // 如果没有相同的商品,保存在最新的位置即可
      const sameIndex = state.list.findIndex(goods => goods.skuId === payload.skuId)
      if (sameIndex !== -1) {
        const count = state.list[sameIndex].count
        // 累加旧的商品
        payload.count += count

        state.list.splice(sameIndex, 1)
      }
      // 追加新的商品
      state.list.unshift(payload)
    },
    // 修改购物车商品
    updateCart (state, goods) {
      // goods中的字段有可能不完整，goods有信息才去修改
      // 1.goods中必须有skuid，才能找到对应的商品信息
      const updateCart = state.list.find(item => item.skuId === goods.skuId)
      console.log(goods)
      for (const key in goods) {
        if (goods[key] !== null && goods[key] !== undefined && goods[key] !== '') {
          updateCart[key] = goods[key]
          console.log(updateCart[key])
        }
      }
    },
    // 删除购物车商品
    deleteCart (state, skuId) {
      console.log(skuId)
      const index = state.list.findIndex(item => item.skuId === skuId)
      state.list.splice(index, 1)
    },

    // 合并购物车商品
    setCartList (state, payload) {
      state.list = payload
    }
  },

  actions: {
    // 加入购物车
    insetCart (ctx, goods) {
      return new Promise((resolve, reject) => {
        // 判断是否登录
        if (ctx.rootState.user.profile.token) {
          // // 已登录
          console.log(goods)
          insetCart({ skuId: goods.skuId, count: goods.count }).then(data => {
            ctx.commit('insetCart', data.result)
            resolve()
          })
        } else {
          ctx.commit('insetCart', goods)
          resolve()
        }
      })
    },
    // 获取购物车列表
    findCartList (ctx) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 登录
          findCartList().then(data => {
            ctx.commit('setCartList', data.result)
          })
        } else {
          // 本地存储
          const promiseArr = ctx.state.list.map(item => {
            // 返回接口函数调用
            return getNewCartGoods(item.skuId)
          })
          Promise.all(promiseArr).then(data => {
            data.forEach((data, index) => {
              ctx.commit('updateCart', { skuId: ctx.state.list[index].skuId, ...data.result })
            })
            resolve()
          }).catch(e => {
            reject(e)
          })
        }
      })
    },
    // 删除购物车商品
    deleteCart (ctx, skuId) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 登录
          deleteCart({ skuId }).then(() => {
            return findCartList()
          }).then(data => {
            ctx.commit('setCartList', data.result)
            resolve()
          })
        } else {
          // 本地
          ctx.commit('deleteCart', skuId)
          resolve()
        }
      })
    },
    // 修改购物车商品
    updateCart (ctx, goods) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 登录
          updateCart(goods).then(() => {
            return findCartList()
          }).then(data => {
            ctx.commit('setCartList', data.result)
            resolve()
          })
        } else {
          ctx.commit('updateCart', goods)
          resolve()
        }
      })
    },
    // 有效商品的全选与反选
    checkAllCart (ctx, selected) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 登录
          const ids = ctx.getters.validList.map(item => item.skuId)
          checkAllCart({ ids, selected }).then(() => {
            return findCartList()
          }).then(data => {
            ctx.commit('setCartList', data.result)
            resolve()
          })
        } else {
          // 本地
          ctx.getters.validList.forEach(item => {
            ctx.commit('updateCart', { skuId: item.skuId, selected })
          })
          resolve()
        }
      })
    },
    batchDeleteCart (ctx, isClear) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
          // 登录
          // 得到需要删除的商品列表, (失效商品,选中商品) 的skuId 集合
          const ids = ctx.getters[isClear ? 'invalidList' : 'selectedList'].map(item => item.skuId)
          deleteCart(ids).then(() => {
            return findCartList()
          }).then(data => {
            ctx.commit('setCartList', data.result)
            resolve()
          })
        } else {
          // 本地
          // 1.获取选中商品列表，进行遍历调用mutations => deleteCart 函数
          ctx.getters[isClear ? 'invalidList' : 'selectedList'].forEach(item => {
            ctx.commit('deleteCart', item.skuId)
          })
          resolve()
        }
      })
    },
    // 修改sku商品规格
    updateCartSku (ctx, { oldSkuId, newSku }) {
      return new Promise((resolve, reject) => {
        if (ctx.rootState.user.profile.token) {
        // 登录
        // 1.获取原先商品数量,
        // 2.删除原先商品
        // 3.获取修改的skuId 和原先商品数量 做一个加入购物车数量
          const oldGoods = ctx.state.list.find(item => item.skuId === oldSkuId)
          console.log(oldGoods)
          deleteCart([oldSkuId]).then(() => {
            console.log(newSku.value, oldGoods.count)
            return insetCart({ skuId: newSku.value.skuId, count: oldGoods.count })
          }).then(() => {
            return findCartList()
          }).then(data => {
            ctx.commit('setCartList', data.result)
            resolve()
          })
        } else {
        // 本地
        // 当修改了sku的时候其实skuId也需要修改，相当于把原来的信息移除，创建一个新的商品信息
        // 1.获取旧的商品sku
          const oldGoods = ctx.state.list.find(item => item.skuId === oldSkuId)
          // 2.删除玖的商品sku
          ctx.commit('deleteCart', oldGoods)

          // 3.合拼新的商品sku
          const { inventory, skuId, specsText: attrsText, price: nowPrice } = newSku.value
          const newGoods = { ...oldGoods, inventory, skuId, attrsText, nowPrice }
          // 插入购物车
          ctx.commit('insetCart', newGoods)
          resolve()
        }
      })
    },
    // 合并购物车商品
    async mergeLocalCart (ctx) {
      // 存储token后调用后台合并API接口函数进行合并操作
      const cartList = ctx.getters.validList.map(({ skuId, selected, count }) => {
        return { skuId, selected, count }
      })
      console.log(cartList)
      await mergeLocalCart(cartList)
      ctx.commit('setCartList', [])
    }
  },

  getters: {
    // 有效商品类表
    validList (state) {
      return state.list.filter(item => item.stock > 0 && item.isEffective)
    },
    // 有效商品总件数
    validTotal (state, getters) {
      return getters.validList.reduce((p, c) => p + c.count, 0)
    },
    // 有效商品总金额
    validAccount (state, getters) {
      return getters.validList.reduce((p, c) => p + Math.round(c.nowPrice * 100) * c.count, 0) / 100
    },
    // 无效商品列表
    invalidList (state) {
      state.list.filter(item => !(item.stock > 0 && item.isEffective))
    },
    // 选中商品列表
    selectedList (state, getters) {
      return getters.validList.filter(item => item.selected)
    },
    // 选中商品件数
    selectedTotal (state, getters) {
      return getters.selectedList.reduce((p, c) => p + c.count, 0)
    },
    // 选中商品的金额
    selectedAccount (state, getters) {
      return getters.selectedList.reduce((p, c) => p + Math.round(c.nowPrice * 100) * c.count, 0) / 100
    },
    // 是否全选
    isCheckAll (state, getters) {
      return getters.validList.length === getters.selectedList.length && getters.selectedList.length !== 0
    }
  }
}
